package com.zhoug.android.common.utils;

import android.util.SparseArray;


import com.zhoug.android.common.interfaces.NameTransformer;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Locale;

import androidx.annotation.NonNull;

/**
 * 集合工具
 * @Author 35574
 * @Date 2020/8/5
 * @Description
 */
public class CollectionUtils {

    /**
     * 非空
     * @param collection
     * @return
     */
    public static boolean notEmpty(Collection<?> collection){
      return collection!=null && collection.size()>0;
    }

    /**
     * 空
     * @param collection
     * @return
     */
    public static boolean isEmpty(Collection<?> collection){
        return collection==null || collection.size()==0;
    }

    /**
     * 把source中的全部数据加入data中
     * @param data
     * @param source
     * @param clearData 是否清空data中的数据后再加入
     * @param <T>
     */
    public static <T> void addAll(@NonNull List<T> data, List<T> source, boolean clearData){
        if(clearData){
            data.clear();
        }
        if(source!=null && source.size()>0){
            data.addAll(source);
        }
    }

    public static <T> void addAll(List<T> data,List<T> source){
        addAll(data,source,false);
    }

    /**
     * 返回list大小
     * @param list
     * @param <T>
     * @return
     */
    public static <T> int size(List<T> list){
        return list!=null ?list.size():0;
    }


    /**
     * list集合转化成String
     *
     * @param list
     * @param split 分割线
     * @param <T>
     * @return
     */
    public static <T extends NameTransformer> String listToNames(List<T> list, String split){
        if(list!=null && list.size()>0){
            if(split==null){
                split="、";
            }
            StringBuilder builder=new StringBuilder();
            for (int i = 0; i < list.size(); i++) {
                builder.append(list.get(i).transformName());
                if(i<list.size()-1){
                    builder.append(split);
                }
            }
            return builder.toString();
        }
        return null;
    }


    /**
     *obj安全的转化为List<T> 泛型检查
     * @param obj
     * @param classOfT
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> List<T> castList(Object obj, Class<T> classOfT) {
        if(obj==null)return null;
        if (obj instanceof List<?>) {
            List<?> objList = (List<?>) obj;
            for (Object item : objList) {
                //a是b的父类或接口,或者a和b为同一个类或同一个接口
                if(!classOfT.isAssignableFrom(item.getClass())){
                    throw new ClassCastException(String.format(Locale.CANADA, "%s不能转化成%s", item.getClass(), classOfT));
                }
            }
            return (List<T>) objList;
        }
        return null;
    }

    /**
     *obj安全的转化为ArrayList<T> 泛型检查
     * @param obj
     * @param classOfT
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> ArrayList<T> castArrayList(Object obj, Class<T> classOfT) {
        if(obj==null)return null;
        if (obj instanceof ArrayList<?>) {
            ArrayList<?> objList = (ArrayList<?>) obj;
            for (Object item : objList) {
                //a是b的父类或接口,或者a和b为同一个类或同一个接口
                if(!classOfT.isAssignableFrom(item.getClass())){
                    throw new ClassCastException(String.format(Locale.CANADA, "%s不能转化成%s", item.getClass(), classOfT));
                }
            }
            return (ArrayList<T>) objList;
        }
        return null;
    }

    /**
     * obj安全的转化为SparseArray<T> 泛型检查
     * @param obj
     * @param classOfT
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> SparseArray<T> castSparseArray(Object obj, Class<T> classOfT) {
        if(obj==null)return null;
        if (obj instanceof SparseArray<?>) {
            SparseArray<?> array = (SparseArray<?>) obj;
            for (int i = 0; i < array.size(); i++) {
                Object item = array.valueAt(i);
                //a是b的父类或接口,或者a和b为同一个类或同一个接口
                if(!classOfT.isAssignableFrom(item.getClass())){
                    throw new ClassCastException(String.format(Locale.CANADA, "%s不能转化成%s", item.getClass(), classOfT));
                }
            }
            return (SparseArray<T>) array;
        }
        return null;
    }




}
